package  org.darcy.framework.generic;

import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

import org.springframework.beans.factory.annotation.Autowired;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;

/**
 * GenericService的实现类, 其他的自定义ServiceImpl, 继承自它,可以获得常用的增删查改操作
 */
public abstract class GenericServiceImpl<T> implements GenericService<T> {

	/**
	 * mysql持久层对象
	 */
	@Autowired(required = false)
	protected GenericDao<T> dao;

	/**
	 * 设置删除状态
	 * 
	 * @param flag 1：删除，0：未删除
	 * 
	 */
	private void setDeleteFlag(T entity, String flag) {
		Class<? extends Object> cls = entity.getClass();
		Method setIsValid;
		try {
			setIsValid = cls.getDeclaredMethod("setDeleteFlag", String.class);
			if (setIsValid != null) {
				setIsValid.invoke(entity, flag);
			}
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 插入对象
	 *
	 * @param T 对象
	 */
	public T insert(T record) {
		dao.insert(record);
		return record;
	}

	/**
	 * 更新对象
	 *
	 * @param record 对象
	 */
	public int update(T record) {
		dao.updateById(record);
		return 1;
	}
	
	/**
	 * 批量更新
	 */
	public int updateBatch(T record, QueryWrapper<T> queryWrapper) {
		return dao.update(record, queryWrapper);
	}

	/**
	 * 通过主键, 删除对象
	 *
	 * @param id 主键
	 */
	public int delete(Object id) {
		dao.deleteById((Serializable) id);
		return 1;
	}

	/**
	 * 通过主键, 查询对象
	 *
	 * @param id 主键
	 * @return
	 */
	public T getById(Object id) {
		return dao.selectById((Serializable) id);
	}

	/**
	 * 批量获取
	 * 
	 * @param ids，多个id，用逗号分隔
	 * @return
	 */
	public List<T> getByIdBatch(String ids) {
		List idList = Arrays.stream(ids.split(",")).collect(Collectors.toList());
		QueryWrapper<T> queryWrapper = new QueryWrapper<T>();
		queryWrapper.in("id", idList);
		return dao.selectList(queryWrapper);
	}

	/**
	 * 根据条件查询列表数据
	 * 
	 * @param queryWrapper
	 * @return
	 */
	public T getOne(Wrapper<T> queryWrapper) {
		return dao.selectOne(queryWrapper);
	}

	/**
	 * 根据条件查询列表数据
	 * 
	 * @param queryWrapper
	 * @return
	 */
	public List<T> getList(Wrapper<T> queryWrapper) {
		return dao.selectList(queryWrapper);
	}

	/**
	 * 根据条件查询列表数据
	 * 
	 * @param queryWrapper
	 * @return
	 */
	public long count(Wrapper<T> queryWrapper) {
		return dao.selectCount(queryWrapper);
	}

	/**
	 * 批量删除
	 * 
	 * @param ids，多个id，用逗号分隔
	 * @return
	 */
	public int deleteBatch(String ids) {
		List idList = Arrays.stream(ids.split(",")).collect(Collectors.toList());
		return dao.deleteBatchIds(idList);
	}

	/**
	 * 根据条件查询列表数据(分页)
	 * 
	 * @param page         分页条件
	 * @param queryWrapper 查询条件
	 * @return
	 */
	public IPage<T> getPage(IPage<T> page, QueryWrapper<T> queryWrapper) {
		return dao.selectPage(page, queryWrapper);
	}



}
